
package org.springboot.szsrcb.controller;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springboot.szsrcb.entity.Req_base_info;
import org.springboot.szsrcb.entity.Req_bill;
import org.springboot.szsrcb.entity.Test_base_info;
import org.springboot.szsrcb.entity.Test_bill;
import org.springboot.szsrcb.entity.Test_testing_info;
import org.springboot.szsrcb.entity.Test_workload_info;
import org.springboot.szsrcb.srvice.Query_Service;
import org.springboot.szsrcb.srvice.Req_bill_Service;
import org.springboot.szsrcb.srvice.Test_bill_Service;
import org.springboot.szsrcb.srvice.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestRestController_query {

	private static final Logger logger = LoggerFactory.getLogger(TestRestController_query.class);

	@Autowired
	private Req_bill_Service req_bill_Service;
	
	@Autowired
	private Test_bill_Service test_bill_Service;
	
	@Autowired
	private Query_Service query_Service;
	


	private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

	@Autowired
	private UserService userService;

	@RequestMapping(value = "/query_test_grid")
	public String query_test_grid(HttpServletRequest request) throws ParseException {
		logger.info("access /req/query_test_grid");
		String g_test_ids = (String) request.getParameter("test_ids");
		String s_tmp="";
		if (g_test_ids != null) {
			g_test_ids = g_test_ids.replace("_", ",");
			s_tmp = json_query_test_grid(g_test_ids);
			logger.info("query_test_grid :" + s_tmp);
		}		
		return s_tmp;

	}

	private String json_query_test_grid(String g_test_ids) {
		String[] array = g_test_ids.split(",");
		String r_s = "";
		String r_start = "{rows:[";
		String r_end = "]}";

		for (int i = 0; i < array.length; i++) {

			String tmp_start = "{ id:" + (i + 1) + ",data:[";
			String tmp_end = "]}";
			String tmp_content = "";

			String g_test_id = array[i];
			Test_bill test_bill = test_bill_Service.search_a_test_bill_by_id(g_test_id);
			Req_bill req_bill=req_bill_Service.req_bill_search_by_id(String.valueOf(test_bill.getReq_id()));
			// radio
			tmp_content = tmp_content + "'0',";
			// Req_ID
			tmp_content = tmp_content + "'" + test_bill.getId() + "',";
			// 需求编号
			tmp_content = tmp_content + "'" + req_bill.getReq_bill_no() + "',";
			// 需求主题
			tmp_content = tmp_content + "'" + req_bill.getReq_title() + "',";
			// 需求状态
			tmp_content = tmp_content + "'" + test_bill.getTest_status() + "',";
			Test_base_info test_base_info = test_bill_Service.search_a_test_base_info_by_testid(g_test_id);
			if (test_base_info != null) {
				// 需求负责人
				tmp_content = tmp_content + "'" + test_base_info.getTest_head() + "',";
				// 需求提出部门
				//tmp_content = tmp_content + "'" + test_bill.getReq_offer_dept() + "',";
				// 要求完成日期
				if (test_bill.getTest_complete_date() == null) {
					tmp_content = tmp_content + "'',";
				} else {
					tmp_content = tmp_content + "'" + sdf.format(test_bill.getTest_complete_date()) + "',";
				}

				// 计划完成日
				if (test_base_info.getTest_plan_date() == null) {
					tmp_content = tmp_content + "'',";
				} else {
					tmp_content = tmp_content + "'" + sdf.format(test_base_info.getTest_plan_date()) + "',";
				}

				// 实际完成日
				if (test_base_info.getActual_finish_date() == null) {
					tmp_content = tmp_content + "'',";
				} else {
					tmp_content = tmp_content + "'" + sdf.format(test_base_info.getActual_finish_date()) + "',";
				}
				// 接收日
				if (test_bill.getCreate_date() == null) {
					tmp_content = tmp_content + "'',";
				} else {
					tmp_content = tmp_content + "'" + sdf.format(test_bill.getCreate_date()) + "'";
				}
			} else {
				// 需求负责人
				tmp_content = tmp_content + "'',";
				// 需求提出部门
				//tmp_content = tmp_content + "'',";
				// 要求完成日期
				tmp_content = tmp_content + "'',";
				// 计划完成日
				tmp_content = tmp_content + "'',";
				// 实际完成日
				tmp_content = tmp_content + "'',";
				// 接收日
				tmp_content = tmp_content + "''";
			}
			if (i == array.length) {
				tmp_end = "]}";
			} else {
				tmp_end = "]},";
			}

			r_s = r_s + tmp_start + tmp_content + tmp_end;
		}
		r_s = r_start + r_s + r_end;
		return r_s;
	}

	@RequestMapping(value = "/query_test_form_send")
	public String query_test_form_send(HttpServletRequest request) throws ParseException {
		logger.info("access /req/query_test_form_send");

		String s_tmp = query_test_form_send_process(request);
		logger.info("query_test_form_send :" + s_tmp);
		return s_tmp;

	}

	private String query_test_form_send_process(HttpServletRequest request) throws ParseException {
		
		String test_workload_date_start = (String) request.getParameter("test_workload_date_start");
		String test_workload_date_end = (String) request.getParameter("test_workload_date_end");
		/*
		 * Map<String, Object> map=new HashMap<String, Object>(); map.put("",
		 * "");
		 */
		List<Test_bill> test_list = test_bill_Service.query_test(request);
		if(test_list==null){
			String r = "0,0,0,0,0,tes_ids=";
			return r;
		}
		// req_count
		int test_count = 0;
		test_count = test_list.size();


		// 实际工作量
		// （1）工作量计算日期之起始日<需求接收日 && （工作量计算日期之终止日>=需求接收日 && 工作量计算日期之终止日<=计划完成日）
		// （2）工作量计算日期之起始日>=需求接收日 && 工作量计算日期之终止日<=计划完成日
		// （3）（工作量计算日期之起始日>=需求接收日 && 工作量计算日期之起始日<=计划完成日） && 工作量计算日期之终止日>计划完成日
		DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		// 计划工作量
		double plan_workload_sum = 0.0;
		double actual_workload_sum = 0.0;
		int deffect_count = 0;
		int tc_count = 0;
		String test_ids = "";
		for (int i = 0; i < test_count; i++) {
			Test_bill test_bill = test_list.get(i);
			if (i == 0) {
				test_ids = test_ids + test_bill.getId();
			} else {
				test_ids = test_ids + "_" + test_bill.getId();
			}
			//计算测试案例数
			tc_count=tc_count+count_test_case_count(test_bill.getId());
			//计算缺陷数
			deffect_count=deffect_count+count_test_deffect_count(test_bill.getId());
			/* if(req_workload_date_start.equals("")){ */
			// dt_req_workload_date_start 为空
			// 工作量计算 起始日取值 1990-01-01
			Date dt_test_workload_date_start = sdf.parse("1990-01-01");
			if (!test_workload_date_start.equals("")) {
				dt_test_workload_date_start =sdf.parse(test_workload_date_start);
			}
			// 工作量计算 终止日 取值
			Date dt_test_workload_date_end = sdf.parse("2099-01-01");
			if (!test_workload_date_end.equals("")) {
				dt_test_workload_date_end = sdf.parse(test_workload_date_end);
			}
			Date g_Accept_date = test_bill.getCreate_date();
			Test_base_info test_base_info = test_bill_Service.search_a_test_base_info_by_testid(String.valueOf(test_bill.getId()));
			// 计划完成时间设置，如果为空，取现在时间
			Date g_test_plan_date = sdf.parse("2099-01-01");
			if (test_base_info != null) {
				g_test_plan_date = test_base_info.getTest_plan_date();
			}			
			
			//计算计划工作量
			double r_plan_workload = count_plan_workload(g_Accept_date, g_test_plan_date, dt_test_workload_date_start,dt_test_workload_date_end, test_bill);
			plan_workload_sum = plan_workload_sum + r_plan_workload;

			// 实际完成时间
			// 实际完成时间设置，如果为空，取现在时间
			Date g_Req_actual_date = sdf.parse("2099-01-01");
			if (test_base_info != null) {
				g_Req_actual_date = test_base_info.getActual_finish_date();
				if(g_Req_actual_date==null){
					actual_workload_sum=actual_workload_sum+0.0;
				}else{
					//计算实际工作量
					double r_actual_workload = count_actual_workload(g_Accept_date, g_Req_actual_date, dt_test_workload_date_start,dt_test_workload_date_end, test_bill);
					actual_workload_sum=actual_workload_sum+r_actual_workload;
				}
				
			}else{
				actual_workload_sum=actual_workload_sum+0.0;
			}
			
			
		}

		String r = test_count+","+tc_count + ","+deffect_count +","+ plan_workload_sum + "," + actual_workload_sum + ",test_ids=" + test_ids;
		return r;
	}

	private int count_test_case_count(Integer id) {
		int return_value=0;
		List<Test_workload_info> workload_info= test_bill_Service.search_test_workload_info(String.valueOf(id));
		if (workload_info != null) {
			for (Test_workload_info test_workload_info : workload_info) {
				return_value=return_value+test_workload_info.getBatch_testcase_count()+test_workload_info.getOnline_testcase_count();
			}
			
		}
		return return_value;
	}

	private int count_test_deffect_count(Integer id) {
		int return_value=0;
		Test_testing_info testing_info= test_bill_Service.search_a_test_testing_info_by_testid(String.valueOf(id));
		if (testing_info != null) {
			return_value=testing_info.getDeffect_critical_count()+testing_info.getDeffect_ordinary_count()+testing_info.getDeffect_other_count();
		}
		return return_value;
	}

	private double count_plan_workload(Date g_Accept_date, Date g_Req_plan_date, Date dt_req_workload_date_start,
			Date dt_req_workload_date_end, Test_bill test_bill) throws ParseException {
		
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
	
	//	create_working_Day(sdf.parse("2016-10-19"),sdf.parse("2017-10-19"));
		
		double r = 0.0;
		try {
			// （1）工作量计算日期之起始日<需求接收日
			if (dt_req_workload_date_start.getTime() < g_Accept_date.getTime()) {
				// &&工作量计算日期之终止日<=需求接收日
				if (dt_req_workload_date_end.getTime() <= g_Accept_date.getTime()) {
					// 工作量=项目或个人计划工作量*（（起始日-终止日）/（需求接收日-终止日）
					r = 0.0;
				} else {
					// &&工作量计算日期之终止日>需求接收日

					if (dt_req_workload_date_end.getTime() >= g_Req_plan_date.getTime()) {
						// &&工作量计算日期之终止日>=计划完成日
						// 工作量=项目或个人计划工作量
						double g_4 = test_bill_Service.get_a_test_all_of_planworkload(test_bill.getId());
						r = g_4;

						/*
						 * long g_1=getDaySub(dt_req_workload_date_start,
						 * dt_req_workload_date_end); long
						 * g_2=getDaySub(g_Accept_date,dt_req_workload_date_end)
						 * ; double g_3=g_1/g_2; double
						 * g_4=req_bill_Service.get_a_req_all_of_planworkload(
						 * req_bill.getId()); r=g_3*g_4;
						 */

					} else {
						// &&工作量计算日期之终止日<计划完成日
						// 工作量=项目或个人计划工作量*（（需求接收日-终止日）/（需求接收日-计划完成日））

						// （（需求接收日-终止日）/（需求接收日-计划完成日））
						double g_1 = getDaySub(g_Accept_date, dt_req_workload_date_end);
						double g_2 = getDaySub(g_Accept_date, g_Req_plan_date);
						double g_3 = g_1 / g_2;
						double g_4 = test_bill_Service.get_a_test_all_of_planworkload(test_bill.getId());
						r = g_3 * g_4;
						BigDecimal b=new BigDecimal(r);
						r=b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
					}
				}

			}
			// （2）工作量计算日期之起始日 >= 需求接收日
			if (dt_req_workload_date_start.getTime() >= g_Accept_date.getTime()) {
				if (dt_req_workload_date_start.getTime()>g_Req_plan_date.getTime()) {
					//工作量计算日期之起始日 > 计划完成日
					r=0.0;
				} else {
					//&&工作量计算日期之起始日 <= 计划完成日
					
					// &&工作量计算日期之终止日>= 需求接收日
					if (dt_req_workload_date_end.getTime() <= g_Accept_date.getTime()) {
						r = 0.0;
					} else {
						// &&工作量计算日期之终止日<= 计划完成日
						if (dt_req_workload_date_end.getTime() <= g_Req_plan_date.getTime()) {
							// 工作量=项目或个人计划工作量*（（起始日-终止日）/（需求接收日-计划完成日））
							double g_1 = getDaySub(dt_req_workload_date_start, dt_req_workload_date_end);
							double g_2 = getDaySub(g_Accept_date, g_Req_plan_date);
							double g_3 = g_1 / g_2;
							double g_4 = test_bill_Service.get_a_test_all_of_planworkload(test_bill.getId());
							r = g_3 * g_4;
							BigDecimal b=new BigDecimal(r);
							r=b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

						} else {
							// &&工作量计算日期之终止日> 计划完成日
							// 工作量=项目或个人计划工作量*（（起始-计划完成日）/（需求接收日-计划完成日））
							double g_1 = getDaySub(dt_req_workload_date_start, g_Req_plan_date);
							double g_2 = getDaySub(g_Accept_date, g_Req_plan_date);
							double g_3 = g_1 / g_2;
							double g_4 = test_bill_Service.get_a_test_all_of_planworkload(test_bill.getId());
							r = g_3 * g_4;
							BigDecimal b=new BigDecimal(r);
							r=b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
						}
					}
				}
			}

		} catch (Exception exception) {
			exception.printStackTrace();
			logger.info(exception.getMessage());
		}
		return r;

	}

	private double count_actual_workload(Date g_Accept_date, Date g_Req_actual_date, Date dt_req_workload_date_start,
			Date dt_req_workload_date_end, Test_bill test_bill) {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm");
		double r = 0.0;
		try {
			// （1）工作量计算日期之起始日<需求接收日
			if (dt_req_workload_date_start.getTime() < g_Accept_date.getTime()) {
				// &&工作量计算日期之终止日<=需求接收日
				if (dt_req_workload_date_end.getTime() <= g_Accept_date.getTime()) {
					// 工作量=项目或个人计划工作量*（（起始日-终止日）/（需求接收日-终止日）
					r = 0.0;
				} else {
					// &&工作量计算日期之终止日>需求接收日

					if (dt_req_workload_date_end.getTime() >= g_Req_actual_date.getTime()) {
						// &&工作量计算日期之终止日>=计划完成日
						// 工作量=项目或个人计划工作量
						double g_4 = test_bill_Service.get_a_test_all_of_actualworkload(test_bill.getId());
						r = g_4;

						/*
						 * long g_1=getDaySub(dt_req_workload_date_start,
						 * dt_req_workload_date_end); long
						 * g_2=getDaySub(g_Accept_date,dt_req_workload_date_end)
						 * ; double g_3=g_1/g_2; double
						 * g_4=req_bill_Service.get_a_req_all_of_planworkload(
						 * req_bill.getId()); r=g_3*g_4;
						 */

					} else {
						// &&工作量计算日期之终止日<计划完成日
						// 工作量=项目或个人计划工作量*（（需求接收日-终止日）/（需求接收日-计划完成日））

						// （（需求接收日-终止日）/（需求接收日-计划完成日））
						double g_1 = getDaySub(g_Accept_date, dt_req_workload_date_end);
						double g_2 = getDaySub(g_Accept_date, g_Req_actual_date);
						double g_3 = g_1 / g_2;
						double g_4 = test_bill_Service.get_a_test_all_of_actualworkload(test_bill.getId());
						r = g_3 * g_4;
						BigDecimal b=new BigDecimal(r);
						r=b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
					}
				}

			}
			// （2）工作量计算日期之起始日 >= 需求接收日
			if (dt_req_workload_date_start.getTime() >= g_Accept_date.getTime()) {
				if (dt_req_workload_date_start.getTime()>g_Req_actual_date.getTime()) {
					//工作量计算日期之起始日 > 计划完成日
					r=0.0;
				} else {
					//&&工作量计算日期之起始日 <= 计划完成日
					
					// &&工作量计算日期之终止日>= 需求接收日
					if (dt_req_workload_date_end.getTime() <= g_Accept_date.getTime()) {
						r = 0.0;
					} else {
						// &&工作量计算日期之终止日<= 计划完成日
						if (dt_req_workload_date_end.getTime() <= g_Req_actual_date.getTime()) {
							// 工作量=项目或个人计划工作量*（（起始日-终止日）/（需求接收日-计划完成日））
							double g_1 = getDaySub(dt_req_workload_date_start, dt_req_workload_date_end);
							double g_2 = getDaySub(g_Accept_date, g_Req_actual_date);
							double g_3 = g_1 / g_2;
							double g_4 = test_bill_Service.get_a_test_all_of_actualworkload(test_bill.getId());
							r = g_3 * g_4;
							BigDecimal b=new BigDecimal(r);
							r=b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

						} else {
							// &&工作量计算日期之终止日> 计划完成日
							// 工作量=项目或个人计划工作量*（（起始-计划完成日）/（需求接收日-计划完成日））
							double g_1 = getDaySub(dt_req_workload_date_start, g_Req_actual_date);
							double g_2 = getDaySub(g_Accept_date, g_Req_actual_date);
							double g_3 = g_1 / g_2;
							double g_4 = test_bill_Service.get_a_test_all_of_actualworkload(test_bill.getId());
							r = g_3 * g_4;
							BigDecimal b=new BigDecimal(r);
							r=b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
						}
					}
				}
			}

		} catch (Exception exception) {
			exception.printStackTrace();
			logger.info(exception.getMessage());
		}
		return r;

	}

	/**
	 * <li>功能描述：时间相减得到天数
	 * 
	 * @param beginDate
	 * @param endDate
	 * @return long
	 * @author qzm
	 */
	public  double getDaySub(Date beginDate, Date endDate) {
		double day = 0.0;
		day=query_Service.getDaySub(beginDate,endDate);
		//day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000) +1;
		// System.out.println("相隔的天数="+day);
		return day;
	}
	
	public void create_working_Day(Date beginDate, Date endDate) {
		Calendar   calendar   =   new   GregorianCalendar(); 
	   
	    Date d=beginDate;
	    calendar.setTime(d); 
	    
		for (int i = 0; beginDate.getTime() < endDate.getTime(); i++) {
			
			calendar.setTime(d);
		     calendar.add(calendar.DATE,i);//把日期往后增加一天.整数往后推,负数往前移动 
		     Date date_tmp=calendar.getTime();   //这个时间就是日期往后推一天的结果 
		     logger.info("calendar="+sdf.format(date_tmp)+" i="+i);
		   //判断时间是否是星期六日		    
			 SimpleDateFormat dateFm = new SimpleDateFormat("EEEE");
			 String g_tmp=dateFm.format(date_tmp);
			 logger.info("g_tmp="+sdf.format(date_tmp)+" "+g_tmp);
		
			 String check_value1="星期六";
			 String check_value2="星期日";
			 boolean is_add=true;
			 if(g_tmp.equals(check_value1)){
				 is_add=false;
			 }
			 if(g_tmp.equals(check_value2)){
				 is_add=false;
			 }
			 if(is_add){
			 query_Service.add_a_date_as_working_date(date_tmp);
			 }
			 beginDate=date_tmp;
				
		}
		
	}

	

}
